/**
 * Copyright (c) Huawei Technologies Co., Ltd. 1987-2021. All rights reserved.
 */

package com.gitee.fufu669.utils;

import org.junit.Test;
import org.springframework.util.CollectionUtils;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

/**
 * 加注释
 */
public class CacheFixNoteLineUtil {

    // 赋值
    private static final String[] FILE_NAMES = {
//            "D:\\javaprojectonhuaweicodehubv2\\experiment_v2\\Ecotest31\\src\\main\\java\\com\\huawei\\ebg\\olblab\\experiment\\sub\\common\\experiment\\sub\\bean\\model\\TExperimentLinkExample.java",
//            "D:\\javaprojectonhuaweicodehubv2\\experiment_v2\\Ecotest31",
//            "D:\\javaprojectonhuaweicodehubv2\\experiment_v2\\Ecotest11",
//            "D:\\javaprojectonhuaweicodehubv2\\experiment_v2\\Ecotest27",
            "D:\\javaprojectonhuaweicodehubv2\\experiment_v2\\Ecotest33"
    };

    // 注解
    @Test
    /**
     *  自动增加注释
     */
    public void autoAddFixNote() {
        // 递归程序加注释
        addFixNoteToJava(FILE_NAMES);
    }

    // 递归程序加注释

    /**
     * 递归程序加注释
     */
    public static void addFixNoteToJava(String[] fileNames) {
        // 遍历
        for (String fileName : fileNames) {
            // 递归程序加注释
            addFixNoteToJava(fileName);
        }
    }

    // 递归程序加注释
    private static void addFixNoteToJava(String fileName) {
        // 递归程序加注释
        addFixNoteToJava(new File(fileName));
    }

    // 递归程序加注释
    private static void addFixNoteToJava(File file) {
        // 如果非空
        if (file != null) {
            // 如果是目录
            if (file.isDirectory()) {
                // 拿列表
                File[] filesInside = file.listFiles();
                // 遍历
                for (File fileInside : filesInside) {
                    // 递归程序加注释
                    addFixNoteToJava(fileInside);
                }
                // 否则
            } else {
                // 判断
                if (file.getName().endsWith(".java")) {
                    System.out.println(file.getPath());
                    // 创建
                    List<String> allLineList = new ArrayList<>();
                    // 尝试下面的代码
                    try (
                            // 创建
                            FileInputStream fileInputStream = new FileInputStream(file);
                            // 创建
                            InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
                            // 创建
                            BufferedReader bufferedReader = new BufferedReader(inputStreamReader)
                    ) {
                        // 定义
                        String line = null;
                        // 读一行
                        while ((line = bufferedReader.readLine()) != null) {
                            // 增加
                            allLineList.add(line);
                        }
                        // 捕捉异常
                    } catch (Exception e) {

                    }
                    // 尝试下面的代码
                    try (
                            // 创建
                            FileInputStream fileInputStream = new FileInputStream(file);
                            // 创建
                            InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
                            // 创建
                            BufferedReader bufferedReader = new BufferedReader(inputStreamReader)
                    ) {
                        // 定义
                        List<String> prevLineList = new ArrayList<>();
                        // 赋值
                        String prevLine = "";
                        // 定义
                        String line = null;
                        // 创建
                        StringBuilder stringBuilder = new StringBuilder();
                        // 赋值
                        int lineCount = 0;
                        // 读一行
                        while ((line = bufferedReader.readLine()) != null) {
                            // 如果是空
                            if (CollectionUtils.isEmpty(prevLineList)) {
                                // 置成目前这行
                                prevLineList.add("first line");
                            }
                            // 把tab换成4个空格
                            line = line.replace("\t", "    ");
                            // 替换
                            line = line.replace(":// ", ":// ");
                            // 替换
                            line = line.replace("// ", "// ");
                            // 替换
                            line = line.replace("// ", "// ");
                            // 替换
                            line = line.replace(", ", ", ");
                            // 替换
                            line = line.replace(",  ", ", ");
                            // 替换
                            line = line.replace(", \n", ",\n");
                            if (line.contains("@return")) {
                                if (!allLineList.get(lineCount - 1).contains("@return")) {
                                    for (int i = lineCount; i < 10 + lineCount; i++) {
                                        if (i < allLineList.size()) {
                                            String nextLine = allLineList.get(i);
                                            if (nextLine.contains("public ") || nextLine.contains("protected ")) {
                                                if (!allLineList.get(lineCount - 1).contains("@param")) {
                                                    try {
                                                        String[] paramsLeft = nextLine.split("\\(");
                                                        if (paramsLeft.length > 1) {
                                                            String[] paramsRight = paramsLeft[1].split("\\)");
                                                            String[] params = paramsRight[0].split(", ");
                                                            for (String param : params) {
                                                                String[] paramItems = param.split(" ");
                                                                if (paramItems.length > 1) {
                                                                    stringBuilder.append(" * @param " + paramItems[1] + " 参数\n");
                                                                }
                                                            }
                                                        }
                                                    } catch (Exception e) {
                                                        e.printStackTrace();
                                                        System.out.println(nextLine);
                                                    }
                                                }
                                                if (nextLine.contains(" void ")) {
                                                    break;
                                                }
                                                if(!nextLine.contains("(")){
                                                    break;
                                                }
                                                stringBuilder.append(" * @return 结果\n");
                                            }
                                        }
                                    }
                                }
                            } else if (line.contains("@param")) {
                                if (!allLineList.get(lineCount - 1).contains("@param")) {
                                    for (int i = lineCount; i < 10 + lineCount; i++) {
                                        String nextLine = allLineList.get(i);
                                        if (nextLine.contains("public ") || nextLine.contains("protected ")) {
                                            if (nextLine.contains("()")) {
                                                break;
                                            }
                                            try {
                                                String[] paramsLeft = nextLine.split("\\(");
                                                if (paramsLeft.length > 1) {
                                                    String[] paramsRight = paramsLeft[1].split("\\)");
                                                    String[] params = paramsRight[0].split(", ");
                                                    for (String param : params) {
                                                        String[] paramItems = param.split(" ");
                                                        if (paramItems.length > 1) {
                                                            stringBuilder.append(" * @param " + paramItems[1] + " 参数\n");
                                                        }
                                                    }
                                                }
                                                break;
                                            } catch (Exception e) {
                                                e.printStackTrace();
                                                System.out.println(nextLine);
                                            }
                                        }
                                    }
                                }
                            } else {
                                if(line.contains("*/")){
                                    String nextCodeLine = allLineList.get(lineCount+1);
                                    if (nextCodeLine.contains("public") || nextCodeLine.contains("protected")) {
                                        if (nextCodeLine.contains("(") && nextCodeLine.contains(")")) {
                                            int noteStartLine = 0;
                                            for (int i = lineCount - 10; i < lineCount; i++) {
                                                String prevNoteLine = allLineList.get(i);
                                                if (prevNoteLine.contains("/*")) {
                                                    noteStartLine = i;
                                                    break;
                                                }
                                            }
                                            if (noteStartLine > 0) {
                                                int isParamFound = 0;
                                                int isReturnFound = 0;
                                                for (int i = noteStartLine; i < 10 + noteStartLine; i++) {
                                                    if(i<allLineList.size()) {
                                                        String nextLine = allLineList.get(i);
                                                        if (isParamFound == 0 && nextLine.contains("@param")) {
                                                            isParamFound = 1;
                                                        }
                                                        if (isReturnFound == 0 && nextLine.contains("@return")) {
                                                            isReturnFound = 1;
                                                        }
                                                    }
                                                }
                                                if (isParamFound == 0 && isReturnFound == 0) {
                                                    String prevCodeLine = allLineList.get(lineCount-1);
                                                    if(!prevCodeLine.trim().equals("*")){
                                                        stringBuilder.append(" * \n");
                                                    }
                                                    try {
                                                        String[] paramsLeft = nextCodeLine.split("\\(");
                                                        if (paramsLeft.length > 1) {
                                                            String[] paramsRight = paramsLeft[1].split("\\)");
                                                            String[] params = paramsRight[0].split(", ");
                                                            for (String param : params) {
                                                                String[] paramItems = param.split(" ");
                                                                if (paramItems.length > 1) {
                                                                    stringBuilder.append(" * @param " + paramItems[1] + " 参数\n");
                                                                }
                                                            }
                                                        }
                                                    } catch (Exception e) {
                                                        e.printStackTrace();
                                                        System.out.println(nextCodeLine);
                                                    }
                                                    if(!nextCodeLine.contains(" void ")){
                                                        stringBuilder.append(" * @return 结果\n");
                                                    }
                                                } else if (isReturnFound ==0){
                                                    String prevCodeLine = allLineList.get(lineCount-1);
                                                    if(!prevCodeLine.trim().equals("*") && prevCodeLine.contains("@param")){
                                                        stringBuilder.append(" * \n");
                                                    }
                                                    if(!nextCodeLine.contains(" void ")){
                                                        stringBuilder.append(" * @return 结果\n");
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                stringBuilder.append(line + "\n");
                            }
                            // 赋值
                            prevLineList.add(line);
                            // 增加
                            lineCount += 1;
                        }
                        // 尝试下面的代码
                        try {
                            System.out.println(stringBuilder.toString());
                            // 创建
                            BufferedWriter out = new BufferedWriter(new FileWriter(file));
                            // 写入
                            out.write(stringBuilder.toString());
                            // 关闭
                            out.close();
                            // 捕捉异常
                        } catch (Exception e) {
                            // 打印异常
                            e.printStackTrace();
                        }
                        // 捕捉异常
                    } catch (Exception e) {
                        // 打印异常
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    // 判断是否不需要增加注释
    private static boolean isNotNeedToAddFixNoteLine(String line, List<String> prevLineList) {
        // 字符串赋值
        String prevLine = prevLineList.get(prevLineList.size() - 1);
        // 是否是注释
        return isNoteLine(line)
                // 上一行是否是不是*/的注释
                || isNotePrevLine(prevLine)
                // 是空
                || line.trim().isEmpty()
                // 或判断
                || (
                // 判断
                line.trim().startsWith("\"")
                        // 与判断
                        && (line.trim().replace(" ", "").endsWith("\"")
                        // 或判断
                        || line.trim().replace(" ", "").endsWith("\"+")
                        // 或判断
                        || line.trim().replace(" ", "").endsWith("\", ")
                        // 或判断
                        || line.trim().replace(" ", "").endsWith("\")")
                        // 或判断
                        || line.trim().replace(" ", "").endsWith("\");")
                        // 或判断
                        || line.trim().replace(" ", "").endsWith("\"), ")
                        // 或判断
                        || line.trim().replace(" ", "").endsWith("\")}")
                        // 或判断
                        || line.trim().replace(" ", "").endsWith("\")}, ")
                        // 或判断
                        || line.trim().replace(" ", "").endsWith("\")};")
                        // 或判断
                        || line.trim().replace(" ", "").endsWith("\";")
                        // 或判断
                        || line.trim().replace(" ", "").endsWith("+")
                ))
                // 引入包不注释
                || line.trim().startsWith("import ")
                // 左花括号不注释
                || line.trim().replace(" ", "").equals("(")
                // 左花括号不注释
                || line.trim().replace(" ", "").equals("((")
                // 左花括号不注释
                || line.trim().replace(" ", "").equals("(((")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals(")")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals(");")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("), ")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("))")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals(")))")
                // 左花括号不注释
                || line.trim().replace(" ", "").equals("{")
                // 左花括号不注释
                || line.trim().replace(" ", "").equals("{{")
                // 左花括号不注释
                || line.trim().replace(" ", "").equals("{{{")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("}")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("};")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("}, ")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("}}")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("}}}")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals(")};")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("});")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("}), ")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals(")}")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("})")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("({")
                // 右花括号不注释
                || line.trim().replace(" ", "").equals("{(")
                // 括号不加注释
                || line.trim().replace(" ", "").equals("){")
                // 括号不加注释
                || line.trim().replace(" ", "").equals("\";")
                // 打日志不注释
                || (line.trim().toLowerCase().contains(".info(") && line.trim().toLowerCase().contains("log"))
                // 打日志不注释
                || (line.trim().toLowerCase().contains(".debug(") && line.trim().toLowerCase().contains("log"))
                // 打日志不注释
                || (line.trim().toLowerCase().contains(".warn(") && line.trim().toLowerCase().contains("log"))
                // 打日志不注释
                || (line.trim().toLowerCase().contains(".error(") && line.trim().toLowerCase().contains("log"));
    }

    // 根据判断拿到注释行
    private static String getNoteLine(String line, List<String> prevLineList, File file, Integer lineCount, String copyrightString, List<String> allLineList) {
        // 字符串赋值
        String prevLine = prevLineList.get(prevLineList.size() - 1);
        // 开始增加注释了
        String noteLine = "";
        // 判断
        if (line.startsWith("package ")) {
            // 判断
            if (lineCount == 1) {
                // 加入
                noteLine += getStartSpace(line) + "/**\n" +
                        // 加入版权消息
                        getStartSpace(line) + copyrightString +
                        // 加入
                        getStartSpace(line) + "*/\n" +
                        "\n";
                // 否则
            } else {
                // 判断
                if (!prevLine.equals("")) {
                    // 加入
                    noteLine += "\n";
                    // 否则
                }
            }
            // 判断
            return noteLine;
        }
        // 判断
        if (line.trim().startsWith("public ") || line.trim().startsWith("protected")) {
            // 判断如果上一行不是以*/开头
            if (!prevLine.trim().startsWith("*/")) {
                // 增加javadoc
                noteLine += (getStartSpace(line) + "/**\n");
                // 上一行是//的注释
                if (prevLine.trim().startsWith("//")) {
                    // 加入上一行注释的文档
                    noteLine += (getStartSpace(line) + " * " + prevLine.trim().replace("//", "") + "\n");
                    // 否则
                } else {
                    // 加入
                    noteLine += (getStartSpace(line) + " * TODO\n");
                }
                // 增加javadoc
                noteLine += (getStartSpace(line) + "*/\n");
            }
            // 判断
            return noteLine;
        }
        // 判断如果上一行是以*/开头
        if (prevLine.trim().startsWith("*/")) {
            // 返回空字符串
            return "";
        }
        // 增加
        noteLine += getStartSpace(line) + "// ";
        // 抛出异常
        if (line.contains("throw new ")) {
            // 加入
            noteLine += "抛出异常";
            // 如果包含
        } else if (line.contains("@RequestHeader")) {
            // 加入
            noteLine += "请求消息头";
            // 如果包含
        } else if (line.contains("@RequestBody")) {
            // 加入
            noteLine += "请求消息体";
            // 如果包含
        } else if (line.contains("@RestController")) {
            // 加入
            noteLine += "控制器注解";
            // 如果包含
        } else if (line.contains("@Controller")) {
            // 加入
            noteLine += "控制器注解";
            // 如果包含
        } else if (line.contains("@RequestMapping")) {
            // 加入
            noteLine += "请求匹配";
            // 如果包含
        } else if (line.contains("@PostMapping")) {
            // 加入
            noteLine += "POST请求匹配";
            // 如果包含
        } else if (line.contains("@GetMapping")) {
            // 加入
            noteLine += "GET请求匹配";
            // 如果包含
        } else if (line.contains("@DeleteMapping")) {
            // 加入
            noteLine += "DELETE请求匹配";
            // 如果包含
        } else if (line.contains("@PutMapping")) {
            // 加入
            noteLine += "PUT请求匹配";
            // 如果包含
        } else if (line.contains("@PathVariable")) {
            // 加入
            noteLine += "路径变量匹配";
            // 如果包含
        } else if (line.contains("@SpringBootApplication")) {
            // 加入
            noteLine += "SpringBoot程序的最主要注解";
            // 如果包含
        } else if (line.contains("@Service")) {
            // 加入
            noteLine += "服务注解";
            // 如果包含
        } else if (line.contains("@Component")) {
            // 加入
            noteLine += "组件注解";
            // 如果包含
        } else if (line.contains("@Configuration")) {
            // 加入
            noteLine += "配置注解";
            // 如果包含
        } else if (line.contains("@Value")) {
            // 加入
            noteLine += "依赖注入值的注解";
            // 如果包含
        } else if (line.contains("@PostConstruct")) {
            // 加入
            noteLine += "延后构造注解";
            // 如果包含
        } else if (line.contains("@ControllerAdvice")) {
            // 加入
            noteLine += "控制器拦截注解";
            // 如果包含
        } else if (line.contains("@ResponseBody")) {
            // 加入
            noteLine += "将java对象转为json的注解";
            // 如果包含
        } else if (line.contains("@Bean")) {
            // 加入
            noteLine += "把对象构造出来注入容器的注解";
            // 如果包含
        } else if (line.contains("@Override")) {
            // 加入
            noteLine += "覆盖父类方法的注解";
            // 如果包含
        } else if (line.trim().startsWith("@")) {
            // 加入
            noteLine += "注解";
            // 如果包含
        } else if (line.trim().startsWith("return ")) {
            // 加入
            noteLine += "返回";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("return;")) {
            // 加入
            noteLine += "返回";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("static{")) {
            // 加入
            noteLine += "静态代码块";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("default:")) {
            // 加入
            noteLine += "默认";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("break;")) {
            // 加入
            noteLine += "跳出";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("continue;")) {
            // 加入
            noteLine += "继续";
            // 如果包含
        } else if (line.contains(" break ")) {
            // 加入
            noteLine += "跳出";
            // 如果包含
        } else if (line.trim().replace(" ", "").startsWith("if(") && line.trim().replace(" ", "").contains("==null")) {
            // 加入
            noteLine += "判断是否是空";
            // 如果包含
        } else if (line.trim().replace(" ", "").startsWith("if(") && line.trim().replace(" ", "").contains("!=null")) {
            // 加入
            noteLine += "判断是否非空";
            // 如果包含
        } else if (line.contains(" if(") || line.contains(" if (")) {
            // 加入
            noteLine += "判断";
            // 如果包含
        } else if (line.contains(" for(") || line.contains(" for (")) {
            // 加入
            noteLine += "遍历";
            // 如果包含
        } else if (line.contains(" while(") || line.contains(" while (")) {
            // 加入
            noteLine += "循环";
            // 如果包含
        } else if (line.contains(" = null ")) {
            // 加入
            noteLine += "赋值成空";
            // 如果包含
        } else if (line.trim().contains("String toString()")) {
            // 加入
            noteLine += "转换成字符串方法";
            // 如果包含
        } else if (line.contains("=new ")) {
            // 加入
            noteLine += "创建";
            // 如果包含
        } else if (line.contains(" new ")) {
            // 加入
            noteLine += "创建";
            // 如果包含
        } else if (line.contains(" = \"")) {
            // 加入
            noteLine += "赋值";
            // 如果包含
        } else if (line.contains("switch")) {
            // 加入
            noteLine += "判断";
            // 如果包含
        } else if (line.contains(" case ") && line.contains(":")) {
            // 加入
            noteLine += "判断";
            // 如果包含
        } else if (line.contains("+=")) {
            // 加入
            noteLine += "增加";
            // 如果包含
        } else if (line.contains("-=")) {
            // 加入
            noteLine += "减少";
            // 如果包含
        } else if (line.contains(" = ") && !line.contains("(")) {
            // 加入
            noteLine += "赋值";
            // 如果包含
        } else if (line.contains(".close()")) {
            // 加入
            noteLine += "关闭";
            // 如果包含
        } else if (line.contains(".write(")) {
            // 加入
            noteLine += "写入";
            // 如果包含
        } else if (line.contains(" || ")) {
            // 加入
            noteLine += "或判断";
            // 如果包含
        } else if (line.contains(" && ")) {
            // 加入
            noteLine += "与判断";
            // 如果包含
        } else if (line.contains("static final Logger")) {
            // 加入
            noteLine += "日志对象";
            // 如果包含
        } else if (line.contains(".replace")) {
            // 加入
            noteLine += "替换";
            // 如果包含
        } else if (line.contains("parse")) {
            // 加入
            noteLine += "转换";
            // 如果包含
        } else if (!line.contains("(") && !line.contains("{")
                // 与判断
                && !line.contains("}") && !line.contains(")") && !line.contains("=")
                // 如果首字母大写
                && line.trim().codePointAt(0) >= 65 && line.trim().codePointAt(0) <= 90
        ) {
            // 加入
            noteLine += "定义";
            // 如果包含
        } else if (!line.contains("(") && !line.contains("{")
                // 与判断
                && !line.contains("}") && !line.contains(")") && !line.contains("=")
                // 如果是8种基本类型
                && (line.trim().startsWith("byte ")
                // 或判断
                || line.trim().startsWith("int ")
                // 或判断
                || line.trim().startsWith("boolean ")
                // 或判断
                || line.trim().startsWith("char ")
                // 或判断
                || line.trim().startsWith("long ")
                // 或判断
                || line.trim().startsWith("double ")
                // 或判断
                || line.trim().startsWith("short ")
                // 或判断
                || line.trim().startsWith("float ")
        )
        ) {
            // 加入
            noteLine += "定义";
            // 如果包含
        } else if (line.contains("Calendar.getInstance();")) {
            // 加入
            noteLine += "拿到日历对象";
            // 如果包含
        } else if (line.contains(".add(Calendar.")) {
            // 加入
            noteLine += "调整日历";
            // 如果包含
        } else if (line.contains("System.getProperty(\"os.name\")")) {
            // 加入
            noteLine += "拿操作系统";
            // 如果包含
        } else if (line.toLowerCase().contains("copy(")) {
            // 加入
            noteLine += "拷贝";
            // 如果包含
        } else if (line.toLowerCase().contains("create(")) {
            // 加入
            noteLine += "创建";
            // 如果包含
        } else if (line.toLowerCase().contains("delete(")) {
            // 加入
            noteLine += "删除";
            // 如果包含
        } else if (line.toLowerCase().contains("add(")) {
            // 加入
            noteLine += "增加";
            // 如果包含
        } else if (line.toLowerCase().contains("update(")) {
            // 加入
            noteLine += "更改";
            // 如果包含
        } else if (line.toLowerCase().contains("query(")) {
            // 加入
            noteLine += "查询";
            // 如果包含
        } else if (line.toLowerCase().contains("select(")) {
            // 加入
            noteLine += "选择";
            // 如果包含
        } else if (line.toLowerCase().contains("listFile(")) {
            // 加入
            noteLine += "拿文件列表";
            // 如果包含
        } else if (line.toLowerCase().contains("list(")) {
            // 加入
            noteLine += "拿列表";
            // 如果包含
        } else if (line.toLowerCase().contains("foreach(")) {
            // 加入
            noteLine += "遍历";
            // 如果包含
        } else if (line.toLowerCase().contains("contains(")) {
            // 加入
            noteLine += "包含";
            // 如果包含
        } else if (line.toLowerCase().contains(".copy")) {
            // 加入
            noteLine += "拷贝";
            // 如果包含
        } else if (line.toLowerCase().contains(".create")) {
            // 加入
            noteLine += "创建";
            // 如果包含
        } else if (line.toLowerCase().contains(".delete")) {
            // 加入
            noteLine += "删除";
            // 如果包含
        } else if (line.toLowerCase().contains(".add")) {
            // 加入
            noteLine += "增加";
            // 如果包含
        } else if (line.toLowerCase().contains(".update")) {
            // 加入
            noteLine += "更改";
            // 如果包含
        } else if (line.toLowerCase().contains(".query")) {
            // 加入
            noteLine += "查询";
            // 如果包含
        } else if (line.toLowerCase().contains(".select")) {
            // 加入
            noteLine += "选择";
            // 如果包含
        } else if (line.toLowerCase().contains(".listFile")) {
            // 加入
            noteLine += "拿文件列表";
            // 如果包含
        } else if (line.toLowerCase().contains(".list")) {
            // 加入
            noteLine += "拿列表";
            // 如果包含
        } else if (line.toLowerCase().contains(".foreach")) {
            // 加入
            noteLine += "遍历";
            // 如果包含
        } else if (line.toLowerCase().contains(".contains")) {
            // 加入
            noteLine += "包含";
            // 如果包含
        } else if (line.toLowerCase().contains(".orElse(")) {
            // 加入
            noteLine += "如果是空拿到默认值，如果非空拿到对象";
            // 如果包含
        } else if (line.toLowerCase().contains(".equals(")) {
            // 加入
            noteLine += "相等";
            // 如果包含
        } else if (line.toLowerCase().contains("boolean equals(")) {
            // 加入
            noteLine += "相等方法";
            // 如果包含
        } else if (line.toLowerCase().contains(".findFirst(")) {
            // 加入
            noteLine += "找到第一个操作";
            // 如果包含
        } else if (line.toLowerCase().contains(".count(")) {
            // 加入
            noteLine += "计数操作";
            // 如果包含
        } else if (line.toLowerCase().contains(".anyMatch(")) {
            // 加入
            noteLine += "任意匹配操作";
            // 如果包含
        } else if (line.toLowerCase().contains(".collect(")) {
            // 加入
            noteLine += "收集操作";
            // 如果包含
        } else if (line.toLowerCase().contains(".filter(")) {
            // 加入
            noteLine += "过滤操作";
            // 如果包含
        } else if (line.toLowerCase().contains(".stream()")) {
            // 加入
            noteLine += "流操作";
            // 如果包含
        } else if (line.toLowerCase().contains("->")) {
            // 加入
            noteLine += "lamda表达式";
            // 如果包含
        } else if (line.trim().startsWith("String ")) {
            // 加入
            noteLine += "字符串赋值";
            // 如果包含
        } else if (line.trim().startsWith("int ")) {
            // 加入
            noteLine += "数字赋值";
            // 如果包含
        } else if (line.trim().startsWith("Integer ")) {
            // 加入
            noteLine += "数字赋值";
            // 如果包含
        } else if (line.contains("Runtime.getRuntime().exec(")) {
            // 加入
            noteLine += "执行命令";
            // 如果包含
        } else if (line.contains(".getInputStream(")) {
            // 加入
            noteLine += "拿到输入流";
            // 如果包含
        } else if (line.contains(".split(")) {
            // 加入
            noteLine += "切分";
            // 如果包含
        } else if (line.contains("Thread.sleep(")) {
            // 加入
            noteLine += "休眠";
            // 如果包含
        } else if (line.contains("++")) {
            // 加入
            noteLine += "加1";
            // 如果包含
        } else if (line.contains("--")) {
            // 加入
            noteLine += "减1";
            // 如果包含
        } else if (line.contains("DriverManager.getConnection(")) {
            // 加入
            noteLine += "拿连接";
            // 如果包含
        } else if (line.contains("Connection connection =")) {
            // 加入
            noteLine += "拿连接";
            // 如果包含
        } else if (line.contains(" catch ")) {
            // 加入
            noteLine += "捕捉异常";
            // 如果包含
        } else if (line.contains("}catch ")) {
            // 加入
            noteLine += "捕捉异常";
            // 如果包含
        } else if (line.contains(" finally")) {
            // 加入
            noteLine += "最终执行";
            // 如果包含
        } else if (line.replace(" ", "").contains("}finally{")) {
            // 加入
            noteLine += "最终执行";
            // 如果包含
        } else if (line.contains("e.printStackTrace();")) {
            // 加入
            noteLine += "打印异常";
            // 如果包含
        } else if (line.contains("Pattern.compile(")) {
            // 加入
            noteLine += "编译正则表达式模板";
            // 如果包含
        } else if (line.contains("Matcher matcher = ")) {
            // 加入
            noteLine += "正则表达式匹配";
            // 如果包含
        } else if (line.contains(".matcher(")) {
            // 加入
            noteLine += "正则表达式匹配";
            // 如果包含
        } else if (line.trim().startsWith("throws ")) {
            // 加入
            noteLine += "抛出异常";
            // 如果包含
        } else if (line.trim().contains(".substring(")) {
            // 加入
            noteLine += "拿子字符串";
            // 如果包含
        } else if (line.trim().contains("System.getProperty(")) {
            // 加入
            noteLine += "拿系统变量";
            // 如果包含
        } else if (line.trim().contains(".mkdirs(")) {
            // 加入
            noteLine += "创建目录";
            // 如果包含
        } else if (line.trim().replace(" ", "").contains("else{")) {
            // 加入
            noteLine += "否则";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("else")) {
            // 加入
            noteLine += "否则";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("try{")) {
            // 加入
            noteLine += "尝试下面的代码";
            // 如果包含
        } else if (line.trim().replace(" ", "").equals("try(")) {
            // 加入
            noteLine += "尝试下面的代码";
            // 如果包含
        } else if (line.trim().startsWith("public void set")
                // 如果set后面的字母大写
                && line.trim().codePointAt(15) >= 65 && line.trim().codePointAt(15) <= 90
        ) {
            // 加入
            noteLine += "自动生成默认写入器";
            // 如果包含
        } else if (line.trim().startsWith("this.") && line.trim().contains(" = ")) {
            // 加入
            noteLine += "自动生成默认写入器写入属性";
            // 如果包含
        } else if (line.trim().startsWith("public ")
                // 与判断
                && line.trim().split(" ").length > 3
                // 与判断
                && line.trim().split(" ")[2].startsWith("get")
                // 如果get后面的字母大写
                && line.trim().split(" ")[2].codePointAt(3) >= 65
                // 与判断
                && line.trim().split(" ")[2].codePointAt(3) <= 90
                // 与判断
                && line.trim().contains("()")
        ) {
            // 加入
            noteLine += "自动生成默认获取器";
            // 如果包含
        } else if (line.trim().contains("public static void main(String[] args) {")) {
            // 加入
            noteLine += "jar包主函数";
            // 如果包含
        } else if (line.trim().contains(".append(")) {
            // 加入
            noteLine += "增加字符串";
            // 如果包含
        } else if (line.trim().contains("list.get(")) {
            // 加入
            noteLine += "从列表里拿数据";
            // 如果包含
        } else if (line.trim().contains(".execute(")) {
            // 加入
            noteLine += "执行";
            // 如果包含
        } else if (line.trim().contains(".toString(")) {
            // 加入
            noteLine += "转换成字符串";
            // 如果包含
        } else if (line.trim().contains(" run(")) {
            // 加入
            noteLine += "运行";
            // 如果包含
        } else if (line.trim().startsWith("@Test")) {
            // 加入
            noteLine += "单例测试注解";
            // 如果包含
        } else if (line.trim().startsWith("HttpEntity ")) {
            // 加入
            noteLine += "获取网页内容";
            // 如果包含
        } else if (line.trim().startsWith("String[] ")) {
            // 加入
            noteLine += "切分";
            // 如果包含
        } else if (line.trim().contains(".put(")) {
            // 加入
            noteLine += "塞入";
            // 如果包含
        } else if (line.trim().contains(".get(")) {
            // 加入
            noteLine += "拿出";
            // 如果包含
        } else if (line.trim().contains(".valueOf(")) {
            // 加入
            noteLine += "转换值";
            // 如果包含
        } else if (line.trim().contains(".flush(")) {
            // 加入
            noteLine += "清空内存的缓冲区数据";
            // 如果包含
        } else if (line.trim().contains(".exec(")) {
            // 加入
            noteLine += "执行命令";
            // 如果包含
        } else if (line.trim().contains(".prepareStatement(")) {
            // 加入
            noteLine += "准备表达式";
            // 如果包含
        } else if (line.trim().contains(".clear()")) {
            // 加入
            noteLine += "清除掉";
            // 如果包含
        } else if (line.trim().contains(" / ")) {
            // 加入
            noteLine += "计算";
            // 如果包含
        } else if (line.trim().contains(".sort(")) {
            // 加入
            noteLine += "排序";
            // 如果包含
        } else if (line.trim().contains("public int compare(")) {
            // 加入
            noteLine += "比较";
            // 如果包含
        } else if (line.trim().contains(".listFiles(")) {
            // 加入
            noteLine += "拿文件列表";
            // 如果包含
        } else if (line.trim().contains("System.out.println")) {
            // 加入
            noteLine += "打印";
            // 如果包含
        } else if (line.trim().contains("zzzzzzzzzzzzzz")) {
            // 加入
            noteLine += "";
            // 否则
        } else {
            // 字符串赋值
            String className = file.getName().split("\\.")[0];
            // 判断
            if (line.contains(" " + className + "()")
            ) {
                // 加入
                noteLine += "构造函数";
                // 否则
            } else {
                // 加入
                noteLine += "TODO";
            }
        }
        // 加入
        noteLine += "\n";
        // 返回
        return noteLine;
    }

    // 拿行开头的空白字符串
    private static String getStartSpace(String line) {
        // 赋值
        String startSpace = "";
        // 遍历
        for (int i = 0; i < line.length() - 1; i++) {
            // 判断
            if (" ".equals(line.substring(i, i + 1))) {
                // 赋值
                startSpace += " ";
                // 否则
            } else {
                // 跳出
                break;
            }
        }
        // 返回
        return startSpace;
    }

    // 上一行是否是不是*/的注释
    private static boolean isNotePrevLine(String line) {
        // 定义
        String firstLetter = null;
        // 尝试下面的代码
        try {
            // 拿前2个字符
            firstLetter = line.trim().substring(0, 1);
            // 捕捉异常
        } catch (Exception e) {
            // 置空
            firstLetter = "";
        }
        // 返回
        return ("/".equals(firstLetter)) && (!line.trim().replace(" ", "").equals("// TODO"));
    }

    // 当前行是否是注释
    private static boolean isNoteLine(String line) {
        // 定义
        String firstLetter = null;
        // 尝试下面的代码
        try {
            // 拿前1个字符
            firstLetter = line.trim().substring(0, 1);
            // 捕捉异常
        } catch (Exception e) {
            // 置空
            firstLetter = "";
        }
        // 赋值
        String last2Letter = null;
        // 尝试下面的代码
        try {
            // 拿最后2个字符
            last2Letter = line.trim().substring(line.length() - 2, line.length());
            // 捕捉异常
        } catch (Exception e) {
            // 置空
            last2Letter = "";
        }
        // 返回
        return ("*/".equals(last2Letter) || "/".equals(firstLetter) || "*".equals(firstLetter)) && (!line.trim().replace(" ", "").equals("// TODO"));
    }

}
